home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 21 / AACD 21.iso / AACD / Utilities / Ghostscript / src / spngp.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-01  |  11.0 KB  |  387 lines
  1. /* Copyright (C) 1996, 1997, 1998, 1999 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of AFPL Ghostscript.
  4.   
  5.   AFPL Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author or
  6.   distributor accepts any responsibility for the consequences of using it, or
  7.   for whether it serves any particular purpose or works at all, unless he or
  8.   she says so in writing.  Refer to the Aladdin Free Public License (the
  9.   "License") for full details.
  10.   
  11.   Every copy of AFPL Ghostscript must include a copy of the License, normally
  12.   in a plain ASCII text file named PUBLIC.  The License grants you the right
  13.   to copy, modify and redistribute AFPL Ghostscript, but only under certain
  14.   conditions described in the License.  Among other things, the License
  15.   requires that the copyright notice and this notice be preserved on all
  16.   copies.
  17. */
  18.  
  19. /*$Id: spngp.c,v 1.2 2000/09/19 19:00:51 lpd Exp $ */
  20. /* PNG pixel prediction filters */
  21. #include "memory_.h"
  22. #include "strimpl.h"
  23. #include "spngpx.h"
  24.  
  25. /* ------ PNGPredictorEncode/Decode ------ */
  26.  
  27. private_st_PNGP_state();
  28.  
  29. /* Define values for case dispatch. */
  30. #define cNone 10
  31. #define cSub 11
  32. #define cUp 12
  33. #define cAverage 13
  34. #define cPaeth 14
  35. #define cOptimum 15
  36. #define cEncode -10
  37. #define cDecode -4
  38. private const byte pngp_case_needs_prev[] = {
  39.     0, 0, 1, 1, 1, 1
  40. };
  41.  
  42. /* Set defaults */
  43. private void
  44. s_PNGP_set_defaults(stream_state * st)
  45. {
  46.     stream_PNGP_state *const ss = (stream_PNGP_state *) st;
  47.  
  48.     s_PNGP_set_defaults_inline(ss);
  49. }
  50.  
  51. /* Common (re)initialization. */
  52. private int
  53. s_PNGP_reinit(stream_state * st)
  54. {
  55.     stream_PNGP_state *const ss = (stream_PNGP_state *) st;
  56.  
  57.     if (ss->prev_row != 0)
  58.     memset(ss->prev_row + ss->bpp, 0, ss->row_count);
  59.     ss->row_left = 0;
  60.     return 0;
  61. }
  62.  
  63. /* Common initialization. */
  64. private int
  65. s_pngp_init(stream_state * st, bool need_prev)
  66. {
  67.     stream_PNGP_state *const ss = (stream_PNGP_state *) st;
  68.     int bits_per_pixel = ss->Colors * ss->BitsPerComponent;
  69.     long bits_per_row = (long)bits_per_pixel * ss->Columns;
  70.     byte *prev_row = 0;
  71.  
  72. #if arch_sizeof_long > arch_sizeof_int
  73.     if (bits_per_row > max_uint * 7L)
  74.     return ERRC;    /****** WRONG ******/
  75. #endif
  76.     ss->row_count = (uint) ((bits_per_row + 7) >> 3);
  77.     ss->end_mask = (1 << (-bits_per_row & 7)) - 1;
  78.     ss->bpp = (bits_per_pixel + 7) >> 3;
  79.     if (need_prev) {
  80.     prev_row = gs_alloc_bytes(st->memory, ss->bpp + ss->row_count,
  81.                   "PNGPredictor prev row");
  82.     if (prev_row == 0)
  83.         return ERRC;    /****** WRONG ******/
  84.     memset(prev_row, 0, ss->bpp);
  85.     }
  86.     ss->prev_row = prev_row;
  87.     /* case_index is only preset for encoding */
  88.     return s_PNGP_reinit(st);
  89. }
  90.  
  91. /* Initialize PNGPredictorEncode filter. */
  92. private int
  93. s_PNGPE_init(stream_state * st)
  94. {
  95.     stream_PNGP_state *const ss = (stream_PNGP_state *) st;
  96.  
  97.     return s_pngp_init(st, pngp_case_needs_prev[ss->Predictor - cNone]);
  98. }
  99.  
  100. /* Initialize PNGPredictorDecode filter. */
  101. private int
  102. s_PNGPD_init(stream_state * st)
  103. {
  104.     return s_pngp_init(st, true);
  105. }
  106.  
  107. /* Release a PNGPredictor filter. */
  108. private void
  109. s_PNGP_release(stream_state *st)
  110. {
  111.     stream_PNGP_state *const ss = (stream_PNGP_state *) st;
  112.  
  113.     if (ss->prev_row)
  114.     gs_free_object(st->memory, ss->prev_row, "PNGPredictor prev row");
  115. }
  116.  
  117. /*
  118.  * Process a partial buffer.  We pass in current and previous pointers
  119.  * to both the current and preceding scan line.  Note that dprev is
  120.  * p - bpp for encoding, q - bpp for decoding; similarly, the 'up' row
  121.  * is the raw data for encoding, the filtered data for decoding.
  122.  * Note also that the case_index cannot be cOptimum.
  123.  */
  124. private int
  125. paeth_predictor(int a, int b, int c)
  126. {
  127.     /* The definitions of ac and bc are correct, not a typo. */
  128.     int ac = b - c, bc = a - c, abcc = ac + bc;
  129.     int pa = (ac < 0 ? -ac : ac), pb = (bc < 0 ? -bc : bc),
  130.     pc = (abcc < 0 ? -abcc : abcc);
  131.  
  132.     return (pa <= pb && pa <= pc ? a : pb <= pc ? b : c);
  133. }
  134. private void
  135. s_pngp_process(stream_state * st, stream_cursor_write * pw,
  136.            const byte * dprev, stream_cursor_read * pr,
  137.            const byte * upprev, const byte * up, uint count)
  138. {
  139.     stream_PNGP_state *const ss = (stream_PNGP_state *) st;
  140.     byte *q = pw->ptr + 1;
  141.     const byte *p = pr->ptr + 1;
  142.  
  143.     pr->ptr += count;
  144.     pw->ptr += count;
  145.     ss->row_left -= count;
  146.     switch (ss->case_index) {
  147.     case cEncode + cNone:
  148.     case cDecode + cNone:
  149.         memcpy(q, p, count);
  150.         break;
  151.     case cEncode + cSub:
  152.         for (; count; ++q, ++dprev, ++p, --count)
  153.         *q = (byte) (*p - *dprev);
  154.         break;
  155.     case cDecode + cSub:
  156.         for (; count; ++q, ++dprev, ++p, --count)
  157.         *q = (byte) (*p + *dprev);
  158.         break;
  159.     case cEncode + cUp:
  160.         for (; count; ++q, ++up, ++p, --count)
  161.         *q = (byte) (*p - *up);
  162.         break;
  163.     case cDecode + cUp:
  164.         for (; count; ++q, ++up, ++p, --count)
  165.         *q = (byte) (*p + *up);
  166.         break;
  167.     case cEncode + cAverage:
  168.         for (; count; ++q, ++dprev, ++up, ++p, --count)
  169.         *q = (byte) (*p - arith_rshift_1((int)*dprev + (int)*up));
  170.         break;
  171.     case cDecode + cAverage:
  172.         for (; count; ++q, ++dprev, ++up, ++p, --count)
  173.         *q = (byte) (*p + arith_rshift_1((int)*dprev + (int)*up));
  174.         break;
  175.     case cEncode + cPaeth:
  176.         for (; count; ++q, ++dprev, ++up, ++upprev, ++p, --count)
  177.         *q = (byte) (*p - paeth_predictor(*dprev, *up, *upprev));
  178.         break;
  179.     case cDecode + cPaeth:
  180.         for (; count; ++q, ++dprev, ++up, ++upprev, ++p, --count)
  181.         *q = (byte) (*p + paeth_predictor(*dprev, *up, *upprev));
  182.         break;
  183.     }
  184. }
  185.  
  186. /* Calculate the number of bytes for the next processing step, */
  187. /* the min of (input data, output data, remaining row length). */
  188. private uint
  189. s_pngp_count(const stream_state * st_const, const stream_cursor_read * pr,
  190.          const stream_cursor_write * pw)
  191. {
  192.     const stream_PNGP_state *const ss_const =
  193.     (const stream_PNGP_state *)st_const;
  194.     uint rcount = pr->limit - pr->ptr;
  195.     uint wcount = pw->limit - pw->ptr;
  196.     uint row_left = ss_const->row_left;
  197.  
  198.     if (rcount < row_left)
  199.     row_left = rcount;
  200.     if (wcount < row_left)
  201.     row_left = wcount;
  202.     return row_left;
  203. }
  204.  
  205. /*
  206.  * Encode a buffer.  Let N = ss->row_count, P = N - ss->row_left,
  207.  * and B = ss->bpp.  Consider that bytes [-B .. -1] of every row are zero.
  208.  * Then:
  209.  *      prev_row[0 .. P - 1] contain bytes -B .. P - B - 1
  210.  *        of the current input row.
  211.  *      ss->prev[0 .. B - 1] contain bytes P - B .. P - 1
  212.  *        of the current input row.
  213.  *      prev_row[P .. N + B - 1] contain bytes P - B .. N - 1
  214.  *        of the previous input row.
  215.  */
  216. private int
  217. optimum_predictor(const stream_state * st, const stream_cursor_read * pr)
  218. {
  219.     return cSub;
  220. }
  221. private int
  222. s_PNGPE_process(stream_state * st, stream_cursor_read * pr,
  223.         stream_cursor_write * pw, bool last)
  224. {
  225.     stream_PNGP_state *const ss = (stream_PNGP_state *) st;
  226.     int bpp = ss->bpp;
  227.     int status = 0;
  228.  
  229.     while (pr->ptr < pr->limit) {
  230.     uint count;
  231.  
  232.     if (ss->row_left == 0) {
  233.         /* Beginning of row, write algorithm byte. */
  234.         int predictor;
  235.  
  236.         if (pw->ptr >= pw->limit) {
  237.         status = 1;
  238.         break;
  239.         }
  240.         predictor =
  241.         (ss->Predictor == cOptimum ?
  242.          optimum_predictor(st, pr) :
  243.          ss->Predictor);
  244.         *++(pw->ptr) = (byte) predictor - cNone;
  245.         ss->case_index = predictor + cEncode;
  246.         ss->row_left = ss->row_count;
  247.         memset(ss->prev, 0, bpp);
  248.         continue;
  249.     }
  250.     count = s_pngp_count(st, pr, pw);
  251.     if (count == 0) {
  252.         /* We know we have input, so output must be full. */
  253.         status = 1;
  254.         break;
  255.     } {
  256.         byte *up = ss->prev_row + bpp + ss->row_count - ss->row_left;
  257.         uint n = min(count, bpp);
  258.  
  259.         /* Process bytes whose predecessors are in prev. */
  260.         s_pngp_process(st, pw, ss->prev, pr, up - bpp, up, n);
  261.         if (ss->prev_row)
  262.         memcpy(up - bpp, ss->prev, n);
  263.         if (ss->row_left == 0)
  264.         continue;
  265.         if (n < bpp) {
  266.         /*
  267.          * We didn't have both enough input data and enough output
  268.          * space to use up all of prev.  Shift more data into prev
  269.          * and exit.
  270.          */
  271.         int prev_left = bpp - n;
  272.  
  273.         memmove(ss->prev, ss->prev + n, prev_left);
  274.         memcpy(ss->prev + prev_left, pr->ptr - (n - 1), n);
  275.         if (pw->ptr >= pw->limit && pr->ptr < pr->limit)
  276.             status = 1;
  277.         break;
  278.         }
  279.         /* Process bytes whose predecessors are in the input. */
  280.         /* We know we have at least bpp input and output bytes, */
  281.         /* and that n = bpp. */
  282.         count -= bpp;
  283.         s_pngp_process(st, pw, pr->ptr - (bpp - 1), pr,
  284.                up, up + bpp, count);
  285.         memcpy(ss->prev, pr->ptr - (bpp - 1), bpp);
  286.         if (ss->prev_row) {
  287.         memcpy(up, pr->ptr - (bpp + count - 1), count);
  288.         if (ss->row_left == 0)
  289.             memcpy(up + count, ss->prev, bpp);
  290.         }
  291.     }
  292.     }
  293.     return status;
  294. }
  295.  
  296. /*
  297.  * Decode a buffer.  Let N = ss->row_count, P = N - ss->row_left,
  298.  * and B = ss->bpp.  Consider that bytes [-B .. -1] of every row are zero.
  299.  * Then:
  300.  *      prev_row[0 .. P - 1] contain bytes -B .. P - B - 1
  301.  *        of the current output row.
  302.  *      ss->prev[0 .. B - 1] contain bytes P - B .. P - 1
  303.  *        of the current output row.
  304.  *      prev_row[P .. N + B - 1] contain bytes P - B .. N - 1
  305.  *        of the previous output row.
  306.  */
  307. private int
  308. s_PNGPD_process(stream_state * st, stream_cursor_read * pr,
  309.         stream_cursor_write * pw, bool last)
  310. {
  311.     stream_PNGP_state *const ss = (stream_PNGP_state *) st;
  312.     int bpp = ss->bpp;
  313.     int status = 0;
  314.  
  315.     while (pr->ptr < pr->limit) {
  316.     uint count;
  317.  
  318.     if (ss->row_left == 0) {
  319.         /* Beginning of row, read algorithm byte. */
  320.         int predictor = pr->ptr[1];
  321.  
  322.         if (predictor >= cOptimum - cNone) {
  323.         status = ERRC;
  324.         break;
  325.         }
  326.         pr->ptr++;
  327.         ss->case_index = predictor + cNone + cDecode;
  328.         ss->row_left = ss->row_count;
  329.         memset(ss->prev, 0, bpp);
  330.         continue;
  331.     }
  332.     count = s_pngp_count(st, pr, pw);
  333.     if (count == 0) {
  334.         /* We know we have input, so output must be full. */
  335.         status = 1;
  336.         break;
  337.     } {
  338.         byte *up = ss->prev_row + bpp + ss->row_count - ss->row_left;
  339.         uint n = min(count, bpp);
  340.  
  341.         /* Process bytes whose predecessors are in prev. */
  342.         s_pngp_process(st, pw, ss->prev, pr, up - bpp, up, n);
  343.         if (ss->prev_row)
  344.         memcpy(up - bpp, ss->prev, n);
  345.         if (ss->row_left == 0)
  346.         continue;
  347.         if (n < bpp) {
  348.         /*
  349.          * We didn't have both enough input data and enough output
  350.          * space to use up all of prev.  Shift more data into prev
  351.          * and exit.
  352.          */
  353.         int prev_left = bpp - n;
  354.  
  355.         memmove(ss->prev, ss->prev + n, prev_left);
  356.         memcpy(ss->prev + prev_left, pw->ptr - (n - 1), n);
  357.         if (pw->ptr >= pw->limit && pr->ptr < pr->limit)
  358.             status = 1;
  359.         break;
  360.         }
  361.         /* Process bytes whose predecessors are in the output. */
  362.         /* We know we have at least bpp input and output bytes, */
  363.         /* and that n = bpp. */
  364.         count -= bpp;
  365.         s_pngp_process(st, pw, pw->ptr - (bpp - 1), pr,
  366.                up, up + bpp, count);
  367.         memcpy(ss->prev, pw->ptr - (bpp - 1), bpp);
  368.         if (ss->prev_row) {
  369.         memcpy(up, pw->ptr - (bpp + count - 1), count);
  370.         if (ss->row_left == 0)
  371.             memcpy(up + count, ss->prev, bpp);
  372.         }
  373.     }
  374.     }
  375.     return status;
  376. }
  377.  
  378. /* Stream templates */
  379. const stream_template s_PNGPE_template = {
  380.     &st_PNGP_state, s_PNGPE_init, s_PNGPE_process, 1, 1, s_PNGP_release,
  381.     s_PNGP_set_defaults, s_PNGP_reinit
  382. };
  383. const stream_template s_PNGPD_template = {
  384.     &st_PNGP_state, s_PNGPD_init, s_PNGPD_process, 1, 1, s_PNGP_release,
  385.     s_PNGP_set_defaults, s_PNGP_reinit
  386. };
  387.